// FavoriteController.js - 收藏控制器
const Favorite = require('../models/Favorite');
const Video = require('../models/Video');

/**
 * 收藏控制器类
 * 处理用户收藏相关的请求
 */
class FavoriteController {
  /**
   * 收藏视频
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async favoriteVideo(req, res) {
    try {
      const { videoId } = req.body;
      const userId = req.user.id;
      
      // 验证参数
      if (!videoId || typeof videoId !== 'number') {
        return res.status(400).json({
          code: 400,
          message: '请提供有效的视频ID',
          data: null
        });
      }
      
      // 检查是否已经收藏
      const isFavorited = await Favorite.checkFavorite(userId, videoId);
      if (isFavorited) {
        return res.status(400).json({
          code: 400,
          message: '您已经收藏过该视频',
          data: null
        });
      }
      
      // 创建收藏记录
      await Favorite.create(userId, videoId);
      
      // 更新视频收藏数
      await Video.updateCollectCount(videoId, 1);
      
      // 获取最新收藏数
      const favoriteCount = await Favorite.getFavoriteCount(videoId);
      
      res.status(200).json({
        code: 200,
        message: '收藏成功',
        data: {
          favorited: true,
          favoriteCount: favoriteCount
        }
      });
    } catch (error) {
      console.error('收藏失败:', error);
      
      // 处理重复收藏的错误（唯一索引冲突）
      if (error.name === 'SequelizeUniqueConstraintError') {
        return res.status(400).json({
          code: 400,
          message: '您已经收藏过该视频',
          data: null
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '收藏失败，请稍后重试',
        data: null
      });
    }
  }

  /**
   * 取消收藏
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async unfavoriteVideo(req, res) {
    try {
      const { videoId } = req.body;
      const userId = req.user.id;
      
      // 验证参数
      if (!videoId || typeof videoId !== 'number') {
        return res.status(400).json({
          code: 400,
          message: '请提供有效的视频ID',
          data: null
        });
      }
      
      // 检查是否已经收藏
      const isFavorited = await Favorite.checkFavorite(userId, videoId);
      if (!isFavorited) {
        return res.status(400).json({
          code: 400,
          message: '您尚未收藏该视频',
          data: null
        });
      }
      
      // 取消收藏
      const result = await Favorite.destroy(userId, videoId);
      
      if (result === 0) {
        return res.status(400).json({
          code: 400,
          message: '取消收藏失败，可能您尚未收藏',
          data: null
        });
      }
      
      // 更新视频收藏数
      await Video.updateCollectCount(videoId, -1);
      
      // 获取最新收藏数
      const favoriteCount = await Favorite.getFavoriteCount(videoId);
      
      res.status(200).json({
        code: 200,
        message: '取消收藏成功',
        data: {
          favorited: false,
          favoriteCount: favoriteCount
        }
      });
    } catch (error) {
      console.error('取消收藏失败:', error);
      res.status(500).json({
        code: 500,
        message: '取消收藏失败，请稍后重试',
        data: null
      });
    }
  }

  /**
   * 检查是否已收藏
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async checkFavoriteStatus(req, res) {
    try {
      const { videoId } = req.query;
      const userId = req.user.id;
      
      // 验证参数
      if (!videoId || typeof parseInt(videoId) !== 'number') {
        return res.status(400).json({
          code: 400,
          message: '请提供有效的视频ID',
          data: null
        });
      }
      
      // 检查收藏状态
      const isFavorited = await Favorite.checkFavorite(userId, parseInt(videoId));
      
      // 获取收藏数
      const favoriteCount = await Favorite.getFavoriteCount(parseInt(videoId));
      
      res.status(200).json({
        code: 200,
        message: '获取收藏状态成功',
        data: {
          favorited: isFavorited,
          favoriteCount: favoriteCount
        }
      });
    } catch (error) {
      console.error('获取收藏状态失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取收藏状态失败，请稍后重试',
        data: null
      });
    }
  }

  /**
   * 获取用户收藏的视频列表
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getUserFavoriteVideos(req, res) {
    try {
      const userId = req.user.id;
      const { page = 1, pageSize = 10 } = req.query;
      
      // 验证参数
      const pageNum = parseInt(page, 10) || 1;
      const size = parseInt(pageSize, 10) || 10;
      
      // 获取用户收藏的视频ID列表
      const videoIds = await Favorite.getUserFavoriteVideos(userId, pageNum, size);
      
      res.status(200).json({
        code: 200,
        message: '获取用户收藏视频列表成功',
        data: {
          videoIds: videoIds,
          page: pageNum,
          pageSize: size
        }
      });
    } catch (error) {
      console.error('获取用户收藏视频列表失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取用户收藏视频列表失败，请稍后重试',
        data: null
      });
    }
  }
}

module.exports = FavoriteController;